package info.niwota.fwrite.img;

import info.niwota.fwrite.ImageViewTouch;
import android.app.Activity;
import android.os.Handler;
import android.view.GestureDetector;
import android.view.MotionEvent;
import android.view.View;
import android.view.View.OnTouchListener;
import android.view.animation.AlphaAnimation;
import android.view.animation.Animation;
import android.widget.ZoomButtonsController;

public class HolderActivity extends Activity {

	private static final long ANIMATION_DURATION = 200;

	private static final long DISMISS_DELAY = 1000; //2000

	private static final long ZOOM_SPEED = 100;

	private final Runnable mDismissControlRunner = new Runnable() {
		public void run() {
			hideControls();
		}
	};

	private final Handler mHandler = new Handler();

//	private final Animation mHideNextImageViewAnimation = new AlphaAnimation(
//			1F, 0F);
//	private final Animation mHidePrevImageViewAnimation = new AlphaAnimation(
//			1F, 0F);

	private Holder mHolder;

//	private final Animation mShowNextImageViewAnimation = new AlphaAnimation(
//			0F, 1F);
//
//	private final Animation mShowPrevImageViewAnimation = new AlphaAnimation(
//			0F, 1F);

	private ZoomButtonsController mZoomButtonsController;

	@Override
	public boolean dispatchTouchEvent(MotionEvent m) {
		if (mHolder.isPaused()) {
			return true;
		}
		if (mZoomButtonsController.isVisible()) {
			scheduleDismissControls();
		}
		return super.dispatchTouchEvent(m);
	}

	protected void hideControls() {
		controlsHiding();
		//
//		View next = mHolder.getNextView();
//		if (next.getVisibility() == View.VISIBLE) {
//			Animation a = mHideNextImageViewAnimation;
//			a.setDuration(ANIMATION_DURATION);
//			next.startAnimation(a);
//			next.setVisibility(View.GONE); // INVISIBLE
//		}
//
//		View prev = mHolder.getPrevView();
//		if (prev.getVisibility() == View.VISIBLE) {
//			Animation a = mHidePrevImageViewAnimation;
//			a.setDuration(ANIMATION_DURATION);
//			prev.startAnimation(a);
//			prev.setVisibility(View.GONE); // INVISIBLE
//		}
		
		mZoomButtonsController.setVisible(false);
	}
	
	protected void controlsHiding() {
	}

	protected void hideView(View panel) {
		if (panel.getVisibility() == View.VISIBLE) {
			Animation a = new AlphaAnimation(1, 0);
			a.setDuration(ANIMATION_DURATION);
			panel.startAnimation(a);
			panel.setVisibility(View.INVISIBLE);
		}
	}

	protected void initControls(Holder holder, final GestureDetector gd) {
		mHolder = holder;
		holder.getDocumentView().setEnableTrackballScroll(true);
		setupZoomButtonController();
		setupOnTouchListeners(gd);
	}

	protected void moveNext() {
		moveNextOrPrevious(1);
	}

	protected void moveNextOrPrevious(int delta) {
		int pos = mHolder.getPosition();
		int nextImagePos = (pos + delta);
		if ((0 <= nextImagePos) && (nextImagePos < mHolder.getCount())) {
			mHolder.showDocument(nextImagePos);
			showControls();
		}
	}

	protected void movePrev() {
		moveNextOrPrevious(-1);
	}

	@Override
	protected void onDestroy() {
		// This is necessary to make the ZoomButtonsController unregister
		// its configuration change receiver.
		ZoomButtonsController c = mZoomButtonsController;
		if (c != null) {
			c.setVisible(false);
		}
		//
		super.onDestroy();
	}

	protected void scheduleDismissControls() {
		mHandler.removeCallbacks(mDismissControlRunner);
		mHandler.postDelayed(mDismissControlRunner, DISMISS_DELAY);
	}

	private void setupOnTouchListeners(final GestureDetector gd) {
		// View root, Holder h,

		// mGestureDetector = gd; //new GestureDetector(this, new
		// MyGestureListener());

		// If the user touches anywhere on the panel (including the
		// next/prev button). We show the on-screen controls. In addition
		// to that, if the touch is not on the prev/next button, we
		// pass the event to the gesture detector to detect double tap.
		final OnTouchListener buttonListener = new OnTouchListener() {
			public boolean onTouch(View v, MotionEvent event) {
				scheduleDismissControls();
				return false;
			}
		};

		OnTouchListener rootListener = new OnTouchListener() {
			public boolean onTouch(View v, MotionEvent event) {
				buttonListener.onTouch(v, event);
				gd.onTouchEvent(event);
				// We do not use the return value of
				// mGestureDetector.onTouchEvent because we will not receive
				// the "up" event if we return false for the "down" event.
				return true;
			}
		};
//		View next = mHolder.getNextView();
//		if (next != null) {
//			next.setOnTouchListener(buttonListener);
//		}
//		View prev = mHolder.getPrevView();
//		if (prev != null) {
//			prev.setOnTouchListener(buttonListener);
//		}

		mHolder.getRoot().setOnTouchListener(rootListener);
	}

	private void setupZoomButtonController() {
		final ZoomButtonsController c = new ZoomButtonsController(mHolder
				.getOwner());
		//
		c.setAutoDismissed(false);
		c.setZoomSpeed(ZOOM_SPEED);
		
		c.setOnZoomListener(new ZoomButtonsController.OnZoomListener() {
			public void onVisibilityChanged(boolean visible) {
				if (visible) {
					updateZoomButtonsEnabled();
				}
			}

			public void onZoom(boolean b) {
				ImageViewTouch d = mHolder.getDocumentView();
				if (d == null) {
					return;
				}
				c.setVisible(true);
				
				zoom(d, b);
				
				updateZoomButtonsEnabled();
				//
			}
		});
		mZoomButtonsController = c;
	}

	/**
	 * 
	 * @param d document view
	 * @param b true zoom in false zoom out
	 */
	protected void zoom(ImageViewTouch d, boolean b) {
		if (b) {
			d.zoomIn();
		} else {
			d.zoomOut();
		}
	}

	protected void showControls() {
		if (mHolder.isPaused()) {
			return;
		}
		controlsShowing();
		
		// If the view has not been attached to the window yet, the
		// zoomButtonControls will not able to show up. So delay it until the
		// view has attached to window.
		View panel = mHolder.getDocumentView(); // mActionIconPanel;
		if (panel.getWindowToken() == null) {
			mHandler.post(new Runnable() {
				public void run() {
					showControls();
				}
			});
			return;
		}

		//updateNextPrevControls();

		updateZoomButtonsEnabled();
		//
		boolean b = mHolder.hasDocument();

		mZoomButtonsController.setVisible(b);
	}

	protected void controlsShowing() {
	}

//	private void updateNextPrevControls() {
//		int pos = mHolder.getPosition();
//		boolean showPrev = (pos > 0);
//		boolean showNext = (pos < mHolder.getCount() - 1);
//		View prev = mHolder.getPrevView();
//		if (prev != null) {
//			boolean prevIsVisible = (prev.getVisibility() == View.VISIBLE);
//			if (showPrev && !prevIsVisible) {
//				Animation a = mShowPrevImageViewAnimation;
//				a.setDuration(ANIMATION_DURATION);
//				prev.startAnimation(a);
//				prev.setVisibility(View.VISIBLE);
//			} else if (!showPrev && prevIsVisible) {
//				Animation a = mHidePrevImageViewAnimation;
//				a.setDuration(ANIMATION_DURATION);
//				prev.startAnimation(a);
//				prev.setVisibility(View.GONE);
//			}
//		}
//		View next = mHolder.getNextView();
//		if (next != null) {
//			boolean nextIsVisible = (next.getVisibility() == View.VISIBLE);
//
//			if (showNext && !nextIsVisible) {
//				Animation a = mShowNextImageViewAnimation;
//				a.setDuration(ANIMATION_DURATION);
//				next.startAnimation(a);
//				next.setVisibility(View.VISIBLE);
//			} else if (!showNext && nextIsVisible) {
//				Animation a = mHideNextImageViewAnimation;
//				a.setDuration(ANIMATION_DURATION);
//				next.startAnimation(a);
//				next.setVisibility(View.GONE);
//			}
//		}
//	}

	private void updateZoomButtonsEnabled() {
		ImageViewTouch iv = mHolder.getDocumentView();
		float scale = iv.getScale();
		ZoomButtonsController c = mZoomButtonsController;
		//
		boolean zin = (scale < iv.mMaxZoom);
		boolean zout = (scale > 1);
		
		c.setZoomInEnabled(zin);
		c.setZoomOutEnabled(zout);
		//
		c.setVisible(true);
		//
	}
}

/**
 * TODO EOF
 */

// private void showScrollLock() {
// mLockScroll.setVisibility(View.VISIBLE);
// scheduleDismissOnScreenControls();
// }

// @Override
// public void onStart() {
// if (Debug.DEBUG) {
// Log.d(TAG, "onStart");
// }
// super.onStart();
// //
// init();
// }

// @Override
// public void onStop() {
// if (Debug.DEBUG) {
// Log.d(TAG, "onStop");
// }
// super.onStop();
// //
// setPaused(true);
//		
// try {

// //
// //saveImage();
// //
// //mPaused = true;
// // mGetter could be null if we call finish() and leave early in
// // onStart().
// // if (mGetter != null) {
// // mGetter.cancelCurrent();
// // mGetter.stop();
// // mGetter = null;
// // }
// //
// // // removing all callback in the message queue
// // mHandler.removeAllGetterCallbacks();
// //
// // if (mAllImages != null) {
// // mAllImages.close();
// // mAllImages = null;
// // }
//
// hideOnScreenControls();
// mImageView.clear();
// } catch (Exception e) {
// e.printStackTrace();
// }
// }

// private boolean scrollLocked;
//
// private class MyGestureListener extends
// GestureDetector.SimpleOnGestureListener {
//
// @Override
// public boolean onDoubleTap(MotionEvent e) {
// // if (scrollLocked) {
// // return true;
// // }
// ImageViewTouch iv = mImageView;
// // save scale if greater than 1.0f or zoom and center at the tap
// // point
// if (iv.getScale() > 1.0f) {
// //saveScaleIf(iv.getScale());
// //
// iv.zoomTo(1f);
// } else {
// // float scale = Preferences.getScale(HolderActivity.this);
// // iv.zoomToPoint(scale, e.getX(), e.getY());
// }
// return true;
// }
//
// @Override
// public boolean onScroll(MotionEvent e1, MotionEvent e2,
// float distanceX, float distanceY) {
// // if (scrollLocked) {
// // return true;
// // }
// ImageViewTouch iv = mImageView;
// if (iv.getScale() > 1.0f) {
// iv.postTranslateCenter(-distanceX, -distanceY);
// }
// return true;
// }
//
// @Override
// public boolean onSingleTapConfirmed(MotionEvent e) {
// // only show screen saver button if scrolling is locked
// // if (scrollLocked) {
// // showScrollLock();
// // return true;
// // }
// showOnScreenControls();
// scheduleDismissOnScreenControls();
// return true;
// }
//
// @Override
// public void onLongPress(MotionEvent e) {
// // toggleScrollLock();
// }
//
// @Override
// public boolean onSingleTapUp(MotionEvent e) {
// return true;
// }
// }

// private static final int DIALOG_HELP = 10;

// private static final String HELP_URI = "file:///android_asset/help.html";

// /* package */static final int RC_PICK = 1;

// private static final int RC_SEND = 2;

// private static final int RC_SETTINGS = 3;

// private static final int RC_SAVE_SCREEN = 4;

// private static final String TAG = "HolderActivity";

// private static final int DIALOG_PICK = 12;

// private static final int DIALOG_REMOVE = 11;

// private static final boolean DEBUG = true; //Debug.DEBUG;

// private View mActionIconPanel;

//
// ImageList mAllImages;

//

// private int mCurrentPosition = 0;

// private Runnable mDeleteImageRunnable = new Runnable() {
// public void run() {
// // mAllImages.removeImageAt(mCurrentPosition);
// int cnt = getCount();
// if (cnt == 0) {
// showBlank();
// return;
// } else {
// if (mCurrentPosition == cnt) {
// mCurrentPosition -= 1;
// }
// }
// mImageView.clear();
// setImage(mCurrentPosition);
// }
// };

// private void updateActionIcons() {
// // View panel = mActionIconPanel;
// // if (panel == null) {
// // return;
// // }
// //
// // panel.setVisibility(View.VISIBLE);
// //
// // boolean b = hasImage();
// // int vi = (b ? View.VISIBLE : View.INVISIBLE);
// // int[] ids = { R.id.remove, R.id.share };
// // for (int i = 0; i < ids.length; i++) {
// // View v = panel.findViewById(ids[i]);
// // v.setEnabled(b);
// // v.setVisibility(vi);
// // }
// }

// protected boolean hasDocument() {
// // boolean b = (mAllImages != null && mAllImages.getCount() > 0);
// return false;
// }

// private void saveScaleIf(float scale) {
// // save if scale is greater than 1.0f
// if (Debug.DEBUG) {
// Log.d(TAG, "saveScaleIf: " + scale);
// }
// // boolean scaled = (scale > 1.0f);
// // if (scaled) {
// // Preferences.putScale(this, scale);
// // }
// // Preferences.putScaled(this, scaled);
// }

// private void saveImage() {
// // save settings
// // ImageViewTouch iv = mImageView;
// // float scale = iv.getScale();
// // float[] values = iv.getMatrix();
// //
// // saveScaleIf(scale);
// //
// // Preferences.putScrollXY(this, values);
// }

// private void showBlank() {
// mImageView.clear();
// //
// updateActionIcons();
// //
// showEmptyText();
// //
// mPrevImageView.setVisibility(View.GONE);
// mNextImageView.setVisibility(View.GONE);
// //
// mSaveScreen.setVisibility(View.GONE);
// mLockScroll.setVisibility(View.GONE);
// }

// private void showEmptyText() {
// if (mTextView == null) {
// return;
// }
// mTextView.setTextSize(16);
// mTextView.setVisibility(View.VISIBLE);
// // mTextView.setText(R.string.text_page_info_none);
// }

// private ImageViewTouch document;

// private View prev;

// private View next;

// /private ImageButton mSaveScreen;

// private ImageButton mLockScroll;

// private Dialog createHelpDialog() {
// LayoutInflater f = LayoutInflater.from(this);
// final View v = f.inflate(R.layout.webdia, null);
// WebView wv = (WebView) v.findViewById(R.id.webview);
// wv.loadUrl(HELP_URI);
// //
// AlertDialog.Builder b = new AlertDialog.Builder(this);
//
// b.setIcon(R.drawable.help);
// b.setTitle(R.string.title_help);
// b.setView(v);
//
// return b.create();
// }

// private TextView mTextView;

// private ImageViewTouch mImageView;

// private View mNextImageView;

// boolean mPaused = true;

// private View mPrevImageView;

// private GestureDetector mGestureDetector;

// private ImageGetter mGetter;

// final GetterHandler mHandler = new GetterHandler();

// private void doAdd(Intent data) {
// try {
// Uri uri = data.getData();
// if (Debug.DEBUG) {
// Log.d(TAG, "doAdd uri: " + uri);
// }
// //
// initList();
// mAllImages.add(this.getContentResolver(), mCurrentPosition, uri);
// //
// Toast.makeText(this, R.string.text_added, Toast.LENGTH_SHORT)
// .show();
// //
// //
// mImageView.clear();
// setImage(mCurrentPosition);
// } catch (Exception e) {
// showError(e);
// e.printStackTrace();
// }
// }

// private void doPick() {
// try {
// if (!WebshotInstallActivity.isWebshotAvailable(this)) {
// showDialog(DIALOG_PICK);
// } else {
// Intent i = createContentIntent();
// final CharSequence title = getText(R.string.text_pick);
// Intent ci = Intent.createChooser(i, title);
// startActivityForResult(ci, RC_PICK);
// }
// } catch (Exception e) {
// showError(e);
// e.printStackTrace();
// }
// }

// private Intent createContentIntent() {
// Intent i = new Intent(Intent.ACTION_GET_CONTENT);
// i.setType("image/*");
// return i;
// }

// /* package */void doRemove() {
// //showDialog(DIALOG_REMOVE);
// }
// private void doSettings() {
// try {
// Intent i = new Intent(this, SettingsActivity.class);
// startActivityForResult(i, RC_SETTINGS);
// } catch (Exception e) {
// // e.printStackTrace();
// }
// }

// private void doShare() {
// IImage image = mAllImages.getImageAt(mCurrentPosition);
// if (image != null) {
// startSendActivity(image);
// }
// }

// /* package */void doSaveScale(float scale) {
// // force save regardless of the scale value
// // Preferences.putScale(this, scale);
// // boolean scaled = (scale > 1.0f);
// // Preferences.putScaled(this, scaled);
// // //
// // Toast.makeText(this, R.string.text_scale_saved, Toast.LENGTH_SHORT)
// // .show();
// }
//
// private void init() {
// if (Debug.DEBUG) {
// Log.d(TAG, "init ");
// }
// //initList();
// //
// // mSaveScreen = (ImageButton) findViewById(R.id.action_save_screen);
// // mSaveScreen.setOnClickListener(this);
// //
// // mLockScroll = (ImageButton) findViewById(R.id.action_lock_scroll);
// // mLockScroll.setOnClickListener(this);
//
// mTextView = (TextView) findViewById(R.id.text);
// mImageView = (ImageViewTouch) findViewById(R.id.document);
//		
// // mActionIconPanel = findViewById(R.id.action_icon_panel);
// // View panel = mActionIconPanel;
// //
// // boolean kb = (KeyguardUtil.isKeyguarded(this));
// // panel.setVisibility(View.VISIBLE);
// //
// // int[] ids = { R.id.add, R.id.share, R.id.remove };
// // for (int id : ids) {
// // View view = panel.findViewById(id);
// // view.setVisibility(View.VISIBLE);
// // view.setOnClickListener(this);
// // }
//		
// mImageView.setEnableTrackballScroll(true);
// //
// setupOnScreenControls(findViewById(R.id.document_root), mImageView);
// //
// //mPaused = false;
// //
// // mGetter = new ImageGetter();
// //
// int cnt = getCount();
// if (cnt == 0) {
// mCurrentPosition = 0;
// //
// showBlank();
// return;
// } else if (cnt <= mCurrentPosition) {
// mCurrentPosition = cnt - 1;
// }
// setImage(mCurrentPosition);
// }

// private void initList() {
// // if (Debug.DEBUG) {
// // Log.d(TAG, "initList " + mAllImages);
// // }
// // if (mAllImages == null) {
// // mAllImages = new ImageList();
// // mAllImages.restore(this);
// // mCurrentPosition = Preferences.getPos(this);
// // //
// // if (Debug.DEBUG) {
// // Log.d(TAG, "initList " + mCurrentPosition + ":" + mAllImages);
// // }
// // }
// }
// public void setImage(int pos) {
// if (Debug.DEBUG) {
// Log.d(TAG, "setImage pos: " + pos);
// }
// //mCurrentPosition = pos;
//
// // ImageGetterCallback cb = new ImageGetterCallback() {
// // public void completed() {
// // }
// //
// // //
// // public int fullImageSizeToUse(int pos, int offset) {
// // // this number should be bigger so that we can zoom. we may
// // // need to get fancier and read in the fuller size image as the
// // // user starts to zoom.
// // // Originally the value is set to 480 in order to avoid OOM.
// // // Now we set it to 2048 because of using
// // // native memory allocation for Bitmaps.
// // final int imageViewSize = 2048;
// // return imageViewSize;
// // }
// //
// // //
// // public void imageLoaded(int pos, int offset, RotateBitmap bitmap,
// // boolean isThumb) {
// // //called twice thumb and full
// // if (Debug.DEBUG) {
// // Log.d(TAG, "imageLoaded current pos: " + mCurrentPosition + " pos: "
// // + pos + " offset: "+ offset+ " bitmap: " + bitmap +" isThumb: " +
// // isThumb);
// // }
// // // shouldn't get here after onPause()
// // //
// // // We may get a result from a previous request. Ignore it.
// // if (pos != mCurrentPosition) {
// // bitmap.recycle();
// // return;
// // }
// //
// // if (offset == 0) {
// // mImageView.setImageRotateBitmapResetBase(bitmap, isThumb);
// // updateZoomButtonsEnabled();
// // //
// // restoreImage(mImageView, isThumb);
// // }
// // }
// //
// // public boolean wantsThumbnail(int pos, int offset) {
// // return true;
// // }
// // //
// // public boolean wantsFullImage(int pos, int offset) {
// // return (offset == 0);
// // }
// //
// // public int[] loadOrder() {
// // return new int[] {0} ; //{0, 1, -1}
// // }
// // };
// //
// // if (mGetter != null) {
// // mGetter.setPosition(pos, cb, mAllImages, mHandler);
// // }
//
// //updateActionIcons();
//
// showOnScreenControls();
//
// scheduleDismissOnScreenControls();
// }

// private void restoreImage(ImageViewTouch iv, boolean isThumb) {
// if (Debug.DEBUG) {
// Log.d(TAG, "restoreImage isThumb:" + isThumb);
// }
// // Context ctx = this;
// // boolean scaled = Preferences.isScaled(ctx);
// // if (Debug.DEBUG) {
// // Log.d(TAG, "scaled: " + scaled);
// // }
// // //
// // if (scaled && iv != null) {
// // float scale = Preferences.getScale(ctx);
// // float[] matrix = Preferences.getScrollXY(ctx);
// // if (Debug.DEBUG) {
// // Log.d(TAG, "scale: " + scale + " matrix: "
// // + Arrays.asList(matrix));
// // }
// // iv.restoreImage(scale, matrix);
// // }
// }

// public int getCount() {

// // mAllImages.getCount()
// return 0;
// }

// @Override
// protected void onActivityResult(int requestCode, int resultCode, Intent
// data) {
// if (Debug.DEBUG) {
// Log.d(TAG, "onActivityResult requestCode: " + requestCode
// + " resultCode:" + resultCode + " == " + RESULT_OK
// + " data: " + data);
// }
// }

// public void onClick(View v) {
// switch (v.getId()) {
// case R.id.next_action:
// moveNextOrPrevious(1);
// break;
// case R.id.prev_action:
// moveNextOrPrevious(-1);
// break;
// // case R.id.action_lock_scroll:
// // toggleScrollLock();
// // break;
// default:
// }
// }

// private void toggleScrollLock() {
// scrollLocked = (!scrollLocked);
// mImageView.setEnableTrackballScroll(!scrollLocked);
// if (Debug.DEBUG) {
// Log.d(TAG, "onLongPress scrollLocked: " + scrollLocked);
// }
// //Context ctx = this;
// //int msg = (scrollLocked? R.string.text_scroll_locked :
// R.string.text_scroll_unlocked);
// //Toast.makeText(ctx, msg, Toast.LENGTH_SHORT).show();
// }

// @Override
// public void onCreate(Bundle instanceState) {
// if (Debug.DEBUG) {
// Log.d(TAG, "onCreate " + instanceState);
// }
// super.onCreate(instanceState);
// //
// // // setDefaultKeyMode(DEFAULT_KEYS_SHORTCUT);
// //
// // requestWindowFeature(Window.FEATURE_NO_TITLE);
// //
// // setContentView(R.layout.imageholder);
// //
// // getWindow().addFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN);
// }

// @Override
// protected Dialog onCreateDialog(int id) {
// // switch (id) {
// // case DIALOG_HELP:
// // return createHelpDialog();
// // case DIALOG_REMOVE:
// // return createRemoveDialog();
// // case DIALOG_PICK:
// // return createPickDialog();
// // default:
// // }
// return super.onCreateDialog(id);
// }

// private Dialog createRemoveDialog() {
// OnClickListener cl = new OnClickListener() {
// public void onClick(DialogInterface dialog, int which) {
// switch (which) {
// case DialogInterface.BUTTON_POSITIVE:
// //
// resetScaled();
// mDeleteImageRunnable.run();
// break;
// default:
// }
// }
// };
// AlertDialog.Builder b = new AlertDialog.Builder(this);
// b.setIcon(android.R.drawable.ic_dialog_alert);
// //b.setTitle(R.string.action_remove);
// //b.setMessage(R.string.text_remove);
// b.setPositiveButton(android.R.string.ok, cl);
// b.setNegativeButton(android.R.string.cancel, cl);
// //
// return b.create();
// }

// private void resetScaled() {
// // Preferences.putScaled(this, false);
// }

// private Dialog createPickDialog() {
// Intent i = createContentIntent();
// return PickDialog.create(this, i, R.string.text_pick);
// }
//
// @Override
// public boolean onCreateOptionsMenu(Menu menu) {
// if (Debug.DEBUG) {
// Log.d(TAG, "onCreateOptionsMenu: " + menu);
// }
// //
// MenuInflater mif = getMenuInflater();
// mif.inflate(R.menu.imageholder_options, menu);
//
// return true;
// }
// @Override
// public void onConfigurationChanged(Configuration newConfig) {
// // seems not working with screen on lock
// if (Debug.DEBUG) {
// Log.d(TAG, "onConfigurationChanged ignored " + newConfig);
// }
// }

// @Override
// public boolean onKeyDown(int keyCode, KeyEvent event) {
// if (Debug.DEBUG) {
// Log.d(TAG, "onKeyDown " + keyCode + " event: " + event);
// }
// // if (scrollLocked) {
// // showScrollLock();
// // return true;
// // }
// return super.onKeyDown(keyCode, event);
// }

//
// boolean b = mHolder.hasDocument();
//
// if (b) {
// mTextView.setVisibility(View.GONE);
// }

// // pagination
// if (b) {
// mTextView.setTextSize(28);
// String pi = getString(R.string.text_page_info,
// mCurrentPosition + 1, getCount());
// mTextView.setText(pi);
// mTextView.setVisibility(View.VISIBLE);
// } else {
// showEmptyText();
// }
// //
// int vi = (b ? View.VISIBLE : View.GONE);
// mSaveScreen.setVisibility(vi);
// mLockScroll.setVisibility(vi);
//
// if (panel.getVisibility() != View.VISIBLE) {
// Animation animation = new AlphaAnimation(0, 1);
// animation.setDuration(ANIMATION_DURATION);
// panel.startAnimation(animation);
// panel.setVisibility(View.VISIBLE);
// }
// protected void showPagination() {
// mTextView.setTextSize(28);
// String pi = getString(R.string.text_page_info,
// mCurrentPosition + 1, getCount());
// mTextView.setText(pi);
// mTextView.setVisibility(View.VISIBLE);
// }
// View rootView, View ownerView
//
// mNextImageView = rootView.findViewById(R.id.next_action);
// mPrevImageView = rootView.findViewById(R.id.prev_action);

// next.setOnClickListener(this);
// prev.setOnClickListener(this);
//
//@Override
//public boolean onPrepareOptionsMenu(Menu menu) {
//	super.onPrepareOptionsMenu(menu);
//	if (mHolder.isPaused()) {
//		return false;
//	}
//	return true;
//}
